﻿using Idlesoft.Utils;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Collections;

namespace UtilsTests
{
    
    
    /// <summary>
    ///This is a test class for EnumerableExtensionsTest and is intended
    ///to contain all EnumerableExtensionsTest Unit Tests
    ///</summary>
	[TestClass()]
	public class EnumerableExtensionsTest
	{


		private TestContext testContextInstance;

		/// <summary>
		///Gets or sets the test context which provides
		///information about and functionality for the current test run.
		///</summary>
		public TestContext TestContext
		{
			get
			{
				return testContextInstance;
			}
			set
			{
				testContextInstance = value;
			}
		}

		#region Additional test attributes
		// 
		//You can use the following additional attributes as you write your tests:
		//
		//Use ClassInitialize to run code before running the first test in the class
		//[ClassInitialize()]
		//public static void MyClassInitialize(TestContext testContext)
		//{
		//}
		//
		//Use ClassCleanup to run code after all tests in a class have run
		//[ClassCleanup()]
		//public static void MyClassCleanup()
		//{
		//}
		//
		//Use TestInitialize to run code before running each test
		//[TestInitialize()]
		//public void MyTestInitialize()
		//{
		//}
		//
		//Use TestCleanup to run code after each test has run
		//[TestCleanup()]
		//public void MyTestCleanup()
		//{
		//}
		//
		#endregion


		/// <summary>
		///A test for Between
		///</summary>
		public void BetweenTestHelper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			object between = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Between<TItem>(items, between);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void BetweenTest()
		{
			BetweenTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Between
		///</summary>
		public void BetweenTest1Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Between<TItem>(items);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void BetweenTest1()
		{
			BetweenTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Flatten
		///</summary>
		public void FlattenTestHelper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			object between = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Flatten<TItem>(items, between);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void FlattenTest()
		{
			FlattenTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Flatten
		///</summary>
		public void FlattenTest1Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Flatten<TItem>(items);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void FlattenTest1()
		{
			FlattenTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Flatten
		///</summary>
		public void FlattenTest2Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			object before = null; // TODO: Initialize to an appropriate value
			object between = null; // TODO: Initialize to an appropriate value
			object after = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Flatten<TItem>(items, before, between, after);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void FlattenTest2()
		{
			FlattenTest2Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Fold
		///</summary>
		public void FoldTestHelper<TAcc, TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			Func<TAcc, TItem, TAcc> func = null; // TODO: Initialize to an appropriate value
			TAcc acc = default(TAcc); // TODO: Initialize to an appropriate value
			TAcc expected = default(TAcc); // TODO: Initialize to an appropriate value
			TAcc actual;
			actual = EnumerableExtensions.Fold<TAcc, TItem>(items, func, acc);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void FoldTest()
		{
			FoldTestHelper<GenericParameterHelper, GenericParameterHelper>();
		}

		/// <summary>
		///A test for FoldLeft
		///</summary>
		public void FoldLeftTestHelper<TAcc, TItem>()
		{
			IList<TItem> items = null; // TODO: Initialize to an appropriate value
			Func<TAcc, TItem, TAcc> func = null; // TODO: Initialize to an appropriate value
			TAcc acc = default(TAcc); // TODO: Initialize to an appropriate value
			TAcc expected = default(TAcc); // TODO: Initialize to an appropriate value
			TAcc actual;
			actual = EnumerableExtensions.FoldLeft<TAcc, TItem>(items, func, acc);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void FoldLeftTest()
		{
			FoldLeftTestHelper<GenericParameterHelper, GenericParameterHelper>();
		}

		/// <summary>
		///A test for FoldRight
		///</summary>
		public void FoldRightTestHelper<TAcc, TItem>()
		{
			IList<TItem> items = null; // TODO: Initialize to an appropriate value
			Func<TAcc, TItem, TAcc> func = null; // TODO: Initialize to an appropriate value
			TAcc acc = default(TAcc); // TODO: Initialize to an appropriate value
			TAcc expected = default(TAcc); // TODO: Initialize to an appropriate value
			TAcc actual;
			actual = EnumerableExtensions.FoldRight<TAcc, TItem>(items, func, acc);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void FoldRightTest()
		{
			FoldRightTestHelper<GenericParameterHelper, GenericParameterHelper>();
		}

		/// <summary>
		///A test for ForEach
		///</summary>
		public void ForEachTestHelper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			Action<TItem> action = null; // TODO: Initialize to an appropriate value
			EnumerableExtensions.ForEach<TItem>(items, action);
			Assert.Inconclusive("A method that does not return a value cannot be verified.");
		}

		[TestMethod()]
		public void ForEachTest()
		{
			ForEachTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for ForEach
		///</summary>
		public void ForEachTest1Helper<TItem>()
		{
			IEnumerable items = null; // TODO: Initialize to an appropriate value
			Action<TItem> action = null; // TODO: Initialize to an appropriate value
			EnumerableExtensions.ForEach<TItem>(items, action);
			Assert.Inconclusive("A method that does not return a value cannot be verified.");
		}

		[TestMethod()]
		public void ForEachTest1()
		{
			ForEachTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Head
		///</summary>
		[TestMethod()]
		public void HeadTest()
		{
			string s = string.Empty; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Head(s, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Head
		///</summary>
		public void HeadTest1Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> expected = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> actual;
			actual = EnumerableExtensions.Head<TItem>(items, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void HeadTest1()
		{
			HeadTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Head
		///</summary>
		public void HeadTest2Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			TItem expected = default(TItem); // TODO: Initialize to an appropriate value
			TItem actual;
			actual = EnumerableExtensions.Head<TItem>(items);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void HeadTest2()
		{
			HeadTest2Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Head
		///</summary>
		[TestMethod()]
		public void HeadTest3()
		{
			string s = string.Empty; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Head(s);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Head
		///</summary>
		public void HeadTest4Helper<TItem>()
		{
			List<TItem> items = null; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			List<TItem> expected = null; // TODO: Initialize to an appropriate value
			List<TItem> actual;
			actual = EnumerableExtensions.Head<TItem>(items, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void HeadTest4()
		{
			HeadTest4Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Head
		///</summary>
		public void HeadTest5Helper<TItem>()
		{
			TItem[] items = null; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			TItem[] expected = null; // TODO: Initialize to an appropriate value
			TItem[] actual;
			actual = EnumerableExtensions.Head<TItem>(items, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void HeadTest5()
		{
			HeadTest5Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Last
		///</summary>
		[TestMethod()]
		public void LastTest()
		{
			string s = string.Empty; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Last(s, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Last
		///</summary>
		public void LastTest1Helper<TItem>()
		{
			TItem[] items = null; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			TItem[] expected = null; // TODO: Initialize to an appropriate value
			TItem[] actual;
			actual = EnumerableExtensions.Last<TItem>(items, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void LastTest1()
		{
			LastTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Last
		///</summary>
		public void LastTest2Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> expected = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> actual;
			actual = EnumerableExtensions.Last<TItem>(items, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void LastTest2()
		{
			LastTest2Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Last
		///</summary>
		[TestMethod()]
		public void LastTest3()
		{
			string s = string.Empty; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Last(s);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Last
		///</summary>
		public void LastTest4Helper<TItem>()
		{
			List<TItem> items = null; // TODO: Initialize to an appropriate value
			int count = 0; // TODO: Initialize to an appropriate value
			List<TItem> expected = null; // TODO: Initialize to an appropriate value
			List<TItem> actual;
			actual = EnumerableExtensions.Last<TItem>(items, count);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void LastTest4()
		{
			LastTest4Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Plus
		///</summary>
		public void PlusTestHelper<TItem>()
		{
			IEnumerable<TItem> lhs = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> rhs = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> expected = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> actual;
			actual = EnumerableExtensions.Plus<TItem>(lhs, rhs);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void PlusTest()
		{
			PlusTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Plus
		///</summary>
		public void PlusTest1Helper<TItem>()
		{
			List<TItem> lhs = null; // TODO: Initialize to an appropriate value
			List<TItem> rhs = null; // TODO: Initialize to an appropriate value
			List<TItem> expected = null; // TODO: Initialize to an appropriate value
			List<TItem> actual;
			actual = EnumerableExtensions.Plus<TItem>(lhs, rhs);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void PlusTest1()
		{
			PlusTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Plus
		///</summary>
		public void PlusTest2Helper<TItem>()
		{
			TItem[] lhs = null; // TODO: Initialize to an appropriate value
			TItem[] rhs = null; // TODO: Initialize to an appropriate value
			TItem[] expected = null; // TODO: Initialize to an appropriate value
			TItem[] actual;
			actual = EnumerableExtensions.Plus<TItem>(lhs, rhs);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void PlusTest2()
		{
			PlusTest2Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Surround
		///</summary>
		public void SurroundTestHelper<TItem>()
		{
			TItem item = default(TItem); // TODO: Initialize to an appropriate value
			object before = null; // TODO: Initialize to an appropriate value
			object after = null; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Surround<TItem>(item, before, after);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void SurroundTest()
		{
			SurroundTestHelper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Tail
		///</summary>
		[TestMethod()]
		public void TailTest()
		{
			string s = string.Empty; // TODO: Initialize to an appropriate value
			string expected = string.Empty; // TODO: Initialize to an appropriate value
			string actual;
			actual = EnumerableExtensions.Tail(s);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		/// <summary>
		///A test for Tail
		///</summary>
		public void TailTest1Helper<TItem>()
		{
			List<TItem> items = null; // TODO: Initialize to an appropriate value
			List<TItem> expected = null; // TODO: Initialize to an appropriate value
			List<TItem> actual;
			actual = EnumerableExtensions.Tail<TItem>(items);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void TailTest1()
		{
			TailTest1Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Tail
		///</summary>
		public void TailTest2Helper<TItem>()
		{
			TItem[] items = null; // TODO: Initialize to an appropriate value
			TItem[] expected = null; // TODO: Initialize to an appropriate value
			TItem[] actual;
			actual = EnumerableExtensions.Tail<TItem>(items);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void TailTest2()
		{
			TailTest2Helper<GenericParameterHelper>();
		}

		/// <summary>
		///A test for Tail
		///</summary>
		public void TailTest3Helper<TItem>()
		{
			IEnumerable<TItem> items = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> expected = null; // TODO: Initialize to an appropriate value
			IEnumerable<TItem> actual;
			actual = EnumerableExtensions.Tail<TItem>(items);
			Assert.AreEqual(expected, actual);
			Assert.Inconclusive("Verify the correctness of this test method.");
		}

		[TestMethod()]
		public void TailTest3()
		{
			TailTest3Helper<GenericParameterHelper>();
		}
	}
}
